home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_mac.hqx / SRGP port to 5.0 (compressed) / SRGP_SPHIGS Root / MacSRGP / srgp_attrib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-13  |  16.6 KB  |  706 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3.  
  4. #define __CURATT(xx)    srgp__curActiveCanvasSpec.attributes.xx
  5.  
  6.  
  7. #ifdef THINK_C
  8. #include "ChooseWhichQuickDraw.h"
  9. #endif
  10.  
  11. #ifdef X11
  12. static XGCValues gcvals;
  13.  
  14. static unsigned char writemode_table[4] = {
  15.    /*REPLACE*/    0x3, /* GXcopy from /usr/include/X11/X.h */
  16.    /*XOR*/     0x6, /* GXxor */
  17.    /*OR*/     0x7, /* GXor */
  18.    /*AND*/     0x1  /* GXand */
  19. };
  20.   
  21. static unsigned char inv_writemode_table[4] = {
  22.    /*REPLACE*/ 0x3, /* GXcopy */
  23.    /*XOR*/     0x9, /* GXequiv */
  24.    /*OR*/      0x1, /* GXand */
  25.    /*AND*/     0x7  /* GXor */
  26. };
  27.  
  28. #endif
  29.  
  30. #ifdef THINK_C
  31. #ifdef COLOR_QUICKDRAW
  32. static unsigned char transfermode_table[4][4] = {
  33.       /*REPLACE,SOLID*/ patCopy,
  34.       /* pixmap pattern entries in this table are unused */ 0,
  35.       /*REPLACE,BITMAP_PATTERN_TRANSPARENT*/ patOr,
  36.       /*REPLACE,BITMAP_PATTERN_OPAQUE*/ patCopy,
  37.       /*XOR,SOLID*/ patXor,
  38.       /* pixmap pattern entries in this table are unused */ 0,
  39.       /*XOR,BITMAP_PATTERN_TRANSPARENT*/ patXor,
  40.       /*XOR,BITMAP_PATTERN_OPAQUE*/ patXor,
  41.       /*OR,SOLID*/ patOr,
  42.       /* pixmap pattern entries in this table are unused */ 0,
  43.       /*OR,BITMAP_PATTERN_TRANSPARENT*/ patOr,
  44.       /*OR,BITMAP_PATTERN_OPAQUE*/ patOr,
  45.       /*AND,SOLID*/ notPatBic,
  46.       /* pixmap pattern entries in this table are unused */ 0,
  47.       /*AND,BITMAP_PATTERN_TRANSPARENT*/ notPatBic,
  48.       /*AND,BITMAP_PATTERN_OPAQUE*/ notPatBic
  49. };
  50.  
  51.  
  52. #define ComputeFrameTransfermode() \
  53.    srgp__curActiveCanvasSpec.transfermode_frame = \
  54.       transfermode_table \
  55.          [srgp__curActiveCanvasSpec.attributes.write_mode] \
  56.          [srgp__curActiveCanvasSpec.attributes.pen_style]
  57.  
  58. #define ComputeFillTransfermode() \
  59.    srgp__curActiveCanvasSpec.transfermode_fill = \
  60.       transfermode_table \
  61.          [srgp__curActiveCanvasSpec.attributes.write_mode] \
  62.          [srgp__curActiveCanvasSpec.attributes.fill_style]
  63.  
  64. #define SetTextTransfermode() \
  65.    TextMode (transfermode_table \
  66.            [srgp__curActiveCanvasSpec.attributes.write_mode] \
  67.            [BITMAP_PATTERN_TRANSPARENT] \
  68.             - 8)
  69.            
  70. #else
  71.  
  72. #define DONT_DRAW   -1
  73.  
  74. #include "srgp_attrib.proto.h"
  75. static void ComputeFrameTransfermode(void);
  76. static void ComputeFillTransfermode(void);
  77. static void SetTextTransfermode(void);
  78. static char *([NUMBER_OF_LINE_STYLES ]);
  79. static void SetXLineAttributes(void);
  80.  
  81. static unsigned char transfermode_table[4][2][4] = {
  82.   {
  83.     /*REPLACE,WHITE,...*/ {notPatCopy, 0, patBic, notPatCopy},
  84.     /*REPLACE,BLACK,...*/ {patCopy, 0, patOr, patCopy},
  85.   },
  86.   {
  87.     /*XOR,WHITE,...*/ {notPatXor, 0, DONT_DRAW, notPatXor},
  88.     /*XOR,BLACK,...*/ {patXor, 0, patXor, patXor} 
  89.   },
  90.   {
  91.     /*OR,WHITE,...*/ {notPatOr, 0, DONT_DRAW, notPatOr},
  92.     /*OR,BLACK,...*/ {patOr, 0, patOr, patOr} 
  93.   },
  94.   {
  95.     /*AND,WHITE,...*/ {patBic, 0, DONT_DRAW, patBic},
  96.     /*AND,BLACK,...*/ {notPatBic, 0, notPatBic, notPatBic} 
  97.   }
  98. };
  99.  
  100.  
  101. static void ComputeFrameTransfermode (void)
  102. {
  103.    srgp__curActiveCanvasSpec.transfermode_frame = 
  104.       transfermode_table[srgp__curActiveCanvasSpec.attributes.write_mode]
  105.            [srgp__curActiveCanvasSpec.attributes.color]
  106.            [srgp__curActiveCanvasSpec.attributes.pen_style];
  107. }
  108.  
  109. static void ComputeFillTransfermode (void)
  110. {
  111.    srgp__curActiveCanvasSpec.transfermode_fill = 
  112.       transfermode_table[srgp__curActiveCanvasSpec.attributes.write_mode]
  113.            [srgp__curActiveCanvasSpec.attributes.color]
  114.            [srgp__curActiveCanvasSpec.attributes.pen_style];
  115. }
  116.  
  117. static void SetTextTransfermode (void) {
  118.    TextMode (transfermode_table
  119.            [srgp__curActiveCanvasSpec.attributes.write_mode] 
  120.         [srgp__curActiveCanvasSpec.attributes.color]
  121.            [BITMAP_PATTERN_TRANSPARENT]
  122.             - 8);
  123. }
  124.  
  125. #endif
  126.  
  127. #endif
  128.  
  129.  
  130.  
  131.  
  132. /** WRITE_MODE
  133. X11 implementation:
  134.    Both GC's must be modified.
  135. **/
  136.  
  137. void
  138. SRGP_setWriteMode (writeMode value)
  139. {
  140.    if (value == __CURATT(write_mode)) return;
  141.  
  142.    DEBUG_AIDS{
  143.       SRGP_trace (SRGP_logStream, "SRGP_setWriteMode  %d\n", value);
  144.       srgp_check_system_state();
  145.       srgp_check_write_mode(value);
  146.       LeaveIfNonFatalErr();
  147.    }
  148.  
  149.    srgp__curActiveCanvasSpec.attributes.write_mode = value;
  150.  
  151. #ifdef X11
  152.    if (XWHITE == 0)
  153.        value = writemode_table[value];
  154.    else
  155.        value = inv_writemode_table[value];
  156.    XSetFunction
  157.       (srgpx__display,
  158.        srgp__curActiveCanvasSpec.gc_frame,
  159.        value);
  160.    XSetFunction
  161.       (srgpx__display,
  162.        srgp__curActiveCanvasSpec.gc_fill,
  163.        value);
  164. #endif
  165. #ifdef THINK_C
  166.    ComputeFrameTransfermode();
  167.    ComputeFillTransfermode();
  168.    SetTextTransfermode();
  169. #endif
  170. }
  171.  
  172.  
  173.  
  174. /** CLIP_RECTANGLE
  175. Both GC's must be modified.
  176. **/
  177. void
  178. SRGP_setClipRectangle (rectangle rect)
  179. {
  180. #ifdef X11
  181.    XRectangle xrect;
  182. #endif
  183. #ifdef THINK_C
  184.    Rect r;
  185. #endif
  186.  
  187.    DEBUG_AIDS{
  188.       SRGP_trace (SRGP_logStream, "SRGP_setClipRect  (%d,%d)->(%d,%d)\n", ExplodeRect(rect));
  189.       srgp_check_system_state();
  190.       srgp_check_rectangle
  191.      (rect.bottom_left.x, rect.bottom_left.y,
  192.       rect.top_right.x, rect.top_right.y);
  193.       LeaveIfNonFatalErr();
  194.    }
  195.  
  196.    srgp__curActiveCanvasSpec.attributes.clip_rectangle = rect;
  197.    
  198. #ifdef X11
  199.    xrect.x = rect.bottom_left.x;
  200.    xrect.y = FIXED(rect.top_right.y);
  201.    xrect.width = (rect.top_right.x - rect.bottom_left.x + 1);
  202.    xrect.height = (rect.top_right.y - rect.bottom_left.y + 1);
  203.    XSetClipRectangles
  204.       (srgpx__display,
  205.        srgp__curActiveCanvasSpec.gc_frame,
  206.        0, 0,
  207.        &xrect, 1, YXSorted);
  208.    XSetClipRectangles
  209.       (srgpx__display,
  210.        srgp__curActiveCanvasSpec.gc_fill,
  211.        0, 0,
  212.        &xrect, 1, YXSorted);
  213. #endif
  214.  
  215. #ifdef THINK_C
  216.    r = FIXED_RECT(ExplodeRect(rect));
  217.    ClipRect(&r);
  218. #endif
  219. }
  220.  
  221.  
  222.  
  223.  
  224. /** FILL STYLE
  225. Only the fill GC is to be modified.
  226. The SRGP fill-style maps directly to X's fill-style.
  227. **/
  228. void
  229. SRGP_setFillStyle (drawStyle value)
  230. {
  231.    if (value == __CURATT(fill_style)) return;
  232.  
  233.    DEBUG_AIDS{
  234.       SRGP_trace (SRGP_logStream, "SRGP_setFillStyle  %d\n", value);
  235.       srgp_check_system_state();
  236.       srgp_check_fill_style(value);
  237.       LeaveIfNonFatalErr();
  238.    }
  239.    
  240.    srgp__curActiveCanvasSpec.attributes.fill_style = value;
  241.    
  242. #ifdef X11
  243.    XSetFillStyle (srgpx__display, srgp__curActiveCanvasSpec.gc_fill, value);
  244. #endif
  245.  
  246. #ifdef THINK_C
  247.    ComputeFillTransfermode();
  248.    srgp__curActiveCanvasSpec.pat_fill = (Pattern*)
  249.       ((value == SOLID) ?
  250.           black :  /*Mac's "solid" pattern*/
  251.           srgp__bitmapPatternTable
  252.              [srgp__curActiveCanvasSpec.attributes.fill_bitmap_pattern_id]);
  253. #endif      
  254. }
  255.  
  256. /*!*/
  257. void
  258. SRGP_setFillBitmapPattern (int value)
  259. {
  260.    if (value == __CURATT(fill_bitmap_pattern_id)) return;
  261.  
  262.    DEBUG_AIDS{
  263.       SRGP_trace (SRGP_logStream, "SRGP_setFillBitmapPattern  %d\n", value);
  264.       srgp_check_system_state();
  265.       srgp_check_pattern_index(value);
  266.       srgp_check_pattern_table_entry(srgp__bitmapPatternTable[value]);
  267.       LeaveIfNonFatalErr();
  268.    }
  269.  
  270.    srgp__curActiveCanvasSpec.attributes.fill_bitmap_pattern_id = value;
  271.  
  272. #ifdef X11
  273.    XSetStipple
  274.       (srgpx__display,
  275.        srgp__curActiveCanvasSpec.gc_fill,
  276.        srgp__bitmapPatternTable[value]);
  277. #endif
  278.  
  279. #ifdef THINK_C
  280.    if (srgp__curActiveCanvasSpec.attributes.fill_style != SOLID)
  281.       srgp__curActiveCanvasSpec.pat_fill = (Pattern*)srgp__bitmapPatternTable[value];
  282. #endif
  283. }
  284.  
  285. /*!*/
  286. void
  287. SRGP_setFillPixmapPattern (int value)
  288. {
  289.    if (value == __CURATT(fill_pixmap_pattern_id)) return;
  290.       
  291.    DEBUG_AIDS{
  292.       SRGP_trace (SRGP_logStream, "SRGP_setFillPixmapPattern  %d\n", value);
  293.       srgp_check_system_state();
  294.       srgp_check_pattern_index(value);
  295.       srgp_check_pattern_table_entry(srgp__pixmapPatternTable[value]);
  296.       LeaveIfNonFatalErr();
  297.    }
  298.  
  299.    srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id = value;
  300.  
  301. #ifdef X11
  302.    gcvals.tile = srgp__pixmapPatternTable[value];
  303.    XChangeGC (srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  304.           GCTile, &gcvals);
  305. #endif
  306. } 
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315. /** PEN STYLE
  316. X11 implementation:
  317.    Only the frame GC is to be modified.
  318.    The SRGP pen-style maps directly to X's fill-style.
  319. **/
  320.  
  321. void
  322. SRGP_setPenStyle (drawStyle value)
  323. {
  324.    if (value == __CURATT(pen_style)) return;
  325.  
  326.    DEBUG_AIDS{
  327.       SRGP_trace (SRGP_logStream, "SRGP_setPenStyle  %d\n", value);
  328.       srgp_check_system_state();
  329.       srgp_check_fill_style(value);
  330.       LeaveIfNonFatalErr();
  331.    }
  332.  
  333.    srgp__curActiveCanvasSpec.attributes.pen_style = value;
  334.  
  335. #ifdef X11
  336.    XSetFillStyle (srgpx__display, srgp__curActiveCanvasSpec.gc_frame, value);
  337. #endif
  338. #ifdef THINK_C
  339.    ComputeFrameTransfermode();
  340.    srgp__curActiveCanvasSpec.pat_frame = (Pattern*)
  341.       ((value == SOLID) ?
  342.          black :  /*Mac's "solid" pattern*/
  343.          srgp__bitmapPatternTable
  344.             [srgp__curActiveCanvasSpec.attributes.pen_bitmap_pattern_id]);
  345. #endif      
  346. }
  347.  
  348. /*!*/
  349. void
  350. SRGP_setPenBitmapPattern (int value)
  351. {
  352.    if (value == __CURATT(pen_bitmap_pattern_id)) return;
  353.  
  354.    DEBUG_AIDS{
  355.       SRGP_trace (SRGP_logStream, "SRGP_setPenBitmapPattern  %d\n", value);
  356.       srgp_check_system_state();
  357.       srgp_check_pattern_index(value);
  358.       srgp_check_pattern_table_entry(srgp__bitmapPatternTable[value]);
  359.       LeaveIfNonFatalErr();
  360.    }
  361.  
  362.    srgp__curActiveCanvasSpec.attributes.pen_bitmap_pattern_id = value;
  363.  
  364. #ifdef X11
  365.    XSetStipple
  366.       (srgpx__display,
  367.        srgp__curActiveCanvasSpec.gc_frame,
  368.        srgp__bitmapPatternTable[value]);
  369. #endif
  370.  
  371. #ifdef THINK_C
  372.    if (srgp__curActiveCanvasSpec.attributes.pen_style != SOLID)
  373.       srgp__curActiveCanvasSpec.pat_frame = 
  374.          (Pattern*) srgp__bitmapPatternTable[value];
  375. #endif
  376. }
  377.  
  378.  
  379.  
  380. /*!*/
  381. void
  382. SRGP_setPenPixmapPattern (int value)
  383. {
  384.    if (value == __CURATT(pen_pixmap_pattern_id)) return;
  385.  
  386.    DEBUG_AIDS{
  387.       SRGP_trace (SRGP_logStream, "SRGP_setPenPixmapPattern  %d\n", value);
  388.       srgp_check_system_state();
  389.       srgp_check_pattern_index(value);
  390.       srgp_check_pattern_table_entry(srgp__pixmapPatternTable[value]);
  391.       LeaveIfNonFatalErr();
  392.    }
  393.  
  394.    srgp__curActiveCanvasSpec.attributes.pen_pixmap_pattern_id = value;
  395.  
  396. #ifdef X11
  397.    gcvals.tile = srgp__pixmapPatternTable[value];
  398.    XChangeGC (srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  399.           GCTile, &gcvals);
  400. #endif
  401. }
  402.  
  403.  
  404.  
  405.  
  406.  
  407.  
  408. /** MARKER ATTRIBUTES
  409. **/
  410.  
  411. void 
  412. SRGP_setMarkerSize (int value)
  413. {
  414.    if (value == __CURATT(marker_size)) return;
  415.  
  416.    DEBUG_AIDS{
  417.       SRGP_trace (SRGP_logStream, "SRGP_setMarkerSize  %d\n", value);
  418.       srgp_check_system_state();
  419.       srgp_check_marker_size(value);
  420.       LeaveIfNonFatalErr();
  421.    }
  422.  
  423.    srgp__curActiveCanvasSpec.attributes.marker_size = value;
  424. }
  425.  
  426.  
  427. void 
  428. SRGP_setMarkerStyle (markerStyle value)
  429. {
  430.    if (value == __CURATT(marker_style)) return;
  431.  
  432.    DEBUG_AIDS{
  433.       SRGP_trace (SRGP_logStream, "SRGP_setMarkerStyle  %d\n", value);
  434.       srgp_check_system_state();
  435.       srgp_check_marker_style(value);
  436.       LeaveIfNonFatalErr();
  437.    }
  438.  
  439.    srgp__curActiveCanvasSpec.attributes.marker_style = value;
  440. }
  441.  
  442.  
  443.  
  444. #ifdef X11
  445. /** TRANSLATING SRGP DASHES TO X 
  446. **/
  447. #define LENGTH_OF_DASH_LIST   4
  448. static char dot[] = {4,4,4,4};
  449. static char dash[] = {10,5,10,5};
  450. static char dotdash[] = {12,4,4,4};
  451. static char *(dashmap[NUMBER_OF_LINE_STYLES ])
  452.    { /*CONTINUOUS: unimportant*/ 0,
  453.      /*DASHED*/ dash,
  454.      /*DOTTED*/ dot,
  455.      /*DOT_DASHED*/ dotdash };
  456.  
  457.  
  458. /** STATIC INTERNAL: SetXLineAttributes()
  459. Notice that when the user desires a line-width of 1, we use 0.
  460. This uses the hardware's fastest line-drawer, according to X.
  461. **/
  462.  
  463. static void SetXLineAttributes(void)
  464. {
  465.    XSetLineAttributes
  466.       (
  467.        srgpx__display,
  468.        srgp__curActiveCanvasSpec.gc_frame,
  469.        ((srgp__curActiveCanvasSpec.attributes.line_width == 1) ?
  470.     0 : srgp__curActiveCanvasSpec.attributes.line_width),
  471.        ((srgp__curActiveCanvasSpec.attributes.line_style==CONTINUOUS) ?
  472.     LineSolid : LineOnOffDash),
  473.        CapButt,        /* CAPS and JOINS are no-ops when line width = 0 */
  474.        JoinBevel);
  475. }
  476. #endif
  477.  
  478.  
  479.  
  480. /*!*/
  481. void
  482. SRGP_setLineStyle (lineStyle value)
  483. {
  484.    if (value == __CURATT(line_style)) return;
  485.  
  486.    DEBUG_AIDS{
  487.       SRGP_trace (SRGP_logStream, "SRGP_setLineStyle  %d\n", value);
  488.       srgp_check_system_state();
  489.       srgp_check_line_style(value);
  490.       LeaveIfNonFatalErr();
  491.    }
  492.  
  493.    srgp__curActiveCanvasSpec.attributes.line_style = value;
  494.  
  495. #ifdef X11
  496.    if (value != CONTINUOUS)
  497.       XSetDashes (srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  498.           0, dashmap[value], LENGTH_OF_DASH_LIST);
  499.    SetXLineAttributes();
  500. #endif
  501. }
  502.  
  503.  
  504.  
  505. /*!*/
  506. void
  507. SRGP_setLineWidth (int value)
  508. {
  509.    if (value == __CURATT(line_width)) return;
  510.  
  511.    DEBUG_AIDS{
  512.       SRGP_trace (SRGP_logStream, "SRGP_setLineWidth  %d\n", value);
  513.       srgp_check_system_state();
  514.       srgp_check_line_width(value);
  515.       LeaveIfNonFatalErr();
  516.    }
  517.  
  518.    srgp__curActiveCanvasSpec.attributes.line_width = value;
  519.    
  520. #ifdef X11
  521.    SetXLineAttributes ();
  522. #endif
  523. #ifdef THINK_C
  524.    PenSize (value,value);
  525. #endif
  526. } 
  527.  
  528.  
  529.  
  530.  
  531.  
  532. /** ATTRIBUTES RELATED TO COLOR
  533. **/
  534.  
  535. void
  536. SRGP_setPlaneMask (int value)
  537. {
  538.    if (value == __CURATT(plane_mask)) return;
  539.  
  540.    DEBUG_AIDS{
  541.       SRGP_trace (SRGP_logStream, "SRGP_setPlaneMask  %x\n", value);
  542.       srgp_check_system_state();
  543.       LeaveIfNonFatalErr();
  544.    }
  545.  
  546.    srgp__curActiveCanvasSpec.attributes.plane_mask = value;
  547.  
  548. #ifdef X11
  549.    XSetPlaneMask
  550.       (srgpx__display, 
  551.        srgp__curActiveCanvasSpec.gc_fill, (unsigned long) value);
  552.    XSetPlaneMask
  553.       (srgpx__display, 
  554.        srgp__curActiveCanvasSpec.gc_frame, (unsigned long) value);
  555. #endif
  556. }
  557.  
  558.  
  559. void
  560. SRGP_setColor (int value)
  561. {
  562.    if (value == __CURATT(color)) return;
  563.  
  564.    DEBUG_AIDS{
  565.       SRGP_trace (SRGP_logStream, "SRGP_setColor  %x\n", value);
  566.       srgp_check_system_state();
  567.       SRGP_correct_color(value);
  568.       LeaveIfNonFatalErr();
  569.    }
  570.  
  571.    if (value > srgp__max_pixel_value)
  572.       value = srgp__max_pixel_value;
  573.    srgp__curActiveCanvasSpec.attributes.color = value;
  574.  
  575. #ifdef X11
  576.    XSetForeground(srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  577.           XCOLOR(COLORINDEX(value)));
  578.    XSetForeground(srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  579.           XCOLOR(COLORINDEX(value)));
  580. #endif
  581.  
  582. #ifdef THINK_C
  583. #ifdef COLOR_QUICKDRAW
  584.    srgp__curActiveCanvasSpec.drawable.win->fgColor = (COLORINDEX(value));
  585. #else
  586.    ComputeFrameTransfermode();
  587.    ComputeFillTransfermode();
  588.    SetTextTransfermode();
  589. #endif
  590. #endif
  591. }
  592.  
  593.  
  594.  
  595. void
  596. SRGP_setBackgroundColor (int value)
  597. {
  598.    if (value == __CURATT(background_color)) return;
  599.  
  600.    DEBUG_AIDS{
  601.       SRGP_trace (SRGP_logStream, "SRGP_setBackgroundColor  %x\n", value);
  602.       srgp_check_system_state();
  603.       SRGP_correct_color(value);
  604.       LeaveIfNonFatalErr();
  605.    }
  606.  
  607.    if (value > srgp__max_pixel_value)
  608.       value = srgp__max_pixel_value;
  609.    srgp__curActiveCanvasSpec.attributes.background_color = value;
  610.  
  611. #ifdef X11
  612.    XSetBackground(srgpx__display, srgp__curActiveCanvasSpec.gc_fill,
  613.           XCOLOR(COLORINDEX(value)));
  614.    XSetBackground(srgpx__display, srgp__curActiveCanvasSpec.gc_frame,
  615.           XCOLOR(COLORINDEX(value)));
  616. #endif
  617.  
  618. #ifdef THINK_C
  619. #ifdef COLOR_QUICKDRAW
  620.    srgp__curActiveCanvasSpec.drawable.win->bkColor = (COLORINDEX(value));
  621. #endif
  622. #endif
  623. }
  624.  
  625.  
  626.  
  627. /** Load Single Color
  628. A convenience subroutine for setting a single color table entry
  629. **/
  630. void SRGP_loadSingleColor
  631.    (int startentry,
  632.     unsigned short redi, 
  633.     unsigned short greeni,
  634.     unsigned short bluei)
  635. {
  636.    PUSH_TRACE;
  637.    SRGP_loadColorTable (startentry, 1, &redi, &greeni, &bluei);
  638.    POP_TRACE;
  639. }
  640.  
  641.  
  642.  
  643.  
  644. /** FONT
  645. The frame gc is used to draw text.  This is a cheat, and violates SRGP's
  646. spec.  This will be fixed someday.
  647. **/
  648. void
  649. SRGP_setFont (int value)
  650. {
  651.    if (value == __CURATT(font)) return;
  652.  
  653.    DEBUG_AIDS{
  654.       SRGP_trace (SRGP_logStream, "SRGP_setFont  %d\n", value);
  655.       srgp_check_system_state();
  656.       srgp_check_extant_font(value);
  657.       LeaveIfNonFatalErr();
  658.    }
  659.  
  660.    srgp__curActiveCanvasSpec.attributes.font = value;
  661.  
  662. #ifdef X11
  663.    XSetFont
  664.       (srgpx__display,
  665.        srgp__curActiveCanvasSpec.gc_frame,
  666.        srgp__fontTable[value]->fid);
  667. #endif
  668. #ifdef THINK_C
  669.       TextFont(srgp__fontTable[value].txFont);
  670.       TextSize(srgp__fontTable[value].txSize);
  671.       TextFace(srgp__fontTable[value].txFace);
  672. #endif
  673. }
  674.  
  675.    
  676.  
  677. /** BATCH SET ATTRIBUTES
  678. Woefully inefficient, but at least I don't reset attributes whose
  679. value has not changed.
  680. **/
  681.  
  682. void
  683. SRGP_setAttributes (attribute_group *att_group)
  684. {
  685.    SRGP_trace (SRGP_logStream, "SRGP_setAttributes 0x%x\n", att_group);
  686.    PUSH_TRACE;
  687.    SRGP_setWriteMode (att_group->write_mode);
  688.    SRGP_setClipRectangle (att_group->clip_rectangle);
  689.  
  690.    SRGP_setFont (att_group->font);
  691.    SRGP_setLineStyle (att_group->line_style);
  692.    SRGP_setLineWidth (att_group->line_width);
  693.    SRGP_setColor (att_group->color);
  694.    SRGP_setPlaneMask (att_group->plane_mask);
  695.    SRGP_setBackgroundColor (att_group->background_color);
  696.    SRGP_setFillStyle (att_group->fill_style);
  697.    SRGP_setFillPixmapPattern (att_group->fill_pixmap_pattern_id);
  698.    SRGP_setFillBitmapPattern (att_group->fill_bitmap_pattern_id);
  699.    SRGP_setPenStyle (att_group->pen_style);
  700.    SRGP_setPenPixmapPattern (att_group->pen_pixmap_pattern_id);
  701.    SRGP_setPenBitmapPattern (att_group->pen_bitmap_pattern_id);
  702.    SRGP_setMarkerSize (att_group->marker_size);
  703.    SRGP_setMarkerStyle (att_group->marker_style);
  704.    POP_TRACE;
  705. }
  706.